OPC Studio User's Guide and Reference
Data Type in OPC UA Write
Client and Subscriber Development > Development Models > Imperative Programming Model > Imperative Programming Model for OPC Data (Classic and UA) > Modifying Information (OPC Data) > Writing Attributes of OPC UA Nodes > Data Type in OPC UA Write
In This Topic

The value written needs to be of correct type, and the data type needs to be passed to the OPC-UA server together with the value.

QuickOPC-UA processes the value and data type in following steps: 

  1. Determine the (CLS-compliant) .NET data type. If you are writing to an attribute other than the Value attribute, the component uses the data type of that attribute as given by the OPC-UA specification, because of these attributes, the data types are fixed.

    Wherever the Value attribute is being written (which is the most common case), and your code has not provided a specific value type, the data type is resolved from the OPC-UA server by reading the DataType and ValueRank attributes of the same node. This is because the type of Value attribute can differ with each node.

    When the data type of the node is not among the standard data types defined in OPC UA, attempts to find its supertype, by following the appropriate reference in the server's address space. This process is repeated if needed, until a known data type is found, or the supertype cannot be determined.

  2. The value that comes from your code is converted to the (CLS-compliant) .NET data type determined in previous step.
  3. Determine the OPC-UA built-in type for the attribute being written. 
  4. If needed, the type of the value is changed to the OPC-UA built-in type determined in the previous step.

As you can see, not specifying the value type is convenient, but causes additional Read and possibly Browse operations on the OPC-UA server in Step 1. This can have negative performance implications. You can prevent the additional Reads with Value attribute by specifying the value type explicitly. When you do so, you must be careful to specify the correct type. For example, if you pass in a value of 199 and specify the value type as a signed integer (Int32 in .NET), QuickOPC will send the value and corresponding type ID to the OPC-UA server as a signed integer. If the server expects a value that must be an unsigned integer, even though the value is otherwise correct (and also non-negative), an error can occur.

How do you specify the value type in your code? This depends on the type of method you are calling. Some methods accept individual arguments, and they have overloads with either valueType or valueTypeCode argument. Other methods accept UAWriteArguments or UAWriteValueArguments object; in this case, you specify the value type by properly setting the ValueType or ValueTypeCode property in this object. There is also a ValueTypeFullName property, which is a string form of the ValueType property. Its use is mainly from COM languages, where the .NET Type is not easily accessible.

The TypeCode can be used for basic, simple types. For more complex types, such as arrays, you need to specify the .NET Type.

When the value type is a null reference, or the value type code is TypeCode.Empty, it means that the value type is not specified, and the component will determine it by interrogating the OPC-UA server, as described at the beginning of the article. 

Examples

Example 1:

The example below writes a single value, specifying the type to be written using a .NET Type.

Note that this example uses an overload of the WriteValue method that is not available in COM. If you are calling from a COM language or tool, use the WriteMultipleValues method instead. An example for that is given further down.

// This example shows how to write a value into a single node, specifying a type explicitly.
//
// Reasons for specifying the type explicitly might be:
// - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
// - The data type that the server reports is incorrect.
// - Writing with an explicitly specified type is more efficient.
//
// For a selected subset of most common types, you can also use a different overload of the WriteValue method, and specify 
// a value from the TypeCode enumeration instead.
//
// Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

using System;
using OpcLabs.EasyOpc.UA;
using OpcLabs.EasyOpc.UA.OperationModel;

namespace UADocExamples._EasyUAClient
{
    partial class WriteValue
    {
        public static void Type()
        {
            UAEndpointDescriptor endpointDescriptor =
                "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer";
            // or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
            // or "https://opcua.demo-this.com:51212/UA/SampleServer/"

            // Instantiate the client object
            var client = new EasyUAClient();

            // Modify value of a node
            try
            {
                client.WriteValue(
                    endpointDescriptor,
                    "nsu=http://test.org/UA/Data/ ;i=10221",
                    12345,
                    typeof(Int32));
            }
            catch (UAException uaException)
            {
                Console.WriteLine("*** Failure: {0}", uaException.GetBaseException().Message);
            }
        }
    }
}
' This example shows how to write a value into a single node, specifying a type explicitly.
'
' Reasons for specifying the type explicitly might be:
' - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
' - The data type that the server reports is incorrect.
' - Writing with an explicitly specified type is more efficient.
'
' For a selected subset of most common types, you can also use a different overload of the WriteValue method, and specify 
' a value from the TypeCode enumeration instead.
'
' Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

Imports System
Imports OpcLabs.EasyOpc.UA
Imports OpcLabs.EasyOpc.UA.OperationModel

Namespace _EasyUAClient
    Partial Friend Class WriteValue
        Public Shared Sub Type()

            ' Define which server we will work with.
            Dim endpointDescriptor As UAEndpointDescriptor =
                    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
            ' or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
            ' or "https://opcua.demo-this.com:51212/UA/SampleServer/"

            ' Instantiate the client object
            Dim client = New EasyUAClient()

            ' Modify value of a node
            Try
                client.WriteValue( _
                    endpointDescriptor, _
                    "nsu=http://test.org/UA/Data/ ;i=10221", _
                    12345, _
                    GetType(Int32))
            Catch uaException As UAException
                Console.WriteLine("*** Failure: {0}", uaException.GetBaseException.Message)
                Exit Sub
            End Try
        End Sub
    End Class
End Namespace

Example 2:

The example below writes a single value, specifying the type to be written using a TypeCode.

Note that this example uses an overload of the WriteValue method that is not available in COM. If you are calling from a COM language or tool, use the WriteMultipleValues method instead. An example for that is given further down.

.NET

// This example shows how to write a value into a single node, specifying a type code explicitly.
//
// Reasons for specifying the type explicitly might be:
// - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
// - The data type that the reports is incorrect.
// - Writing with an explicitly specified type is more efficient.
//
// TypeCode is easy to use, but it does not cover all possible types. It is also possible to specify the .NET Type, using
// a different overload of the WriteValue method.
//
// Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

using System;
using OpcLabs.EasyOpc.UA;
using OpcLabs.EasyOpc.UA.OperationModel;

namespace UADocExamples._EasyUAClient
{
    partial class WriteValue
    {
        public static void TypeCode()
        {
            UAEndpointDescriptor endpointDescriptor =
                "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer";
            // or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
            // or "https://opcua.demo-this.com:51212/UA/SampleServer/"

            // Instantiate the client object.
            var client = new EasyUAClient();

            Console.WriteLine("Modifying value of a node...");
            try
            {
                client.WriteValue(
                    endpointDescriptor,
                    "nsu=http://test.org/UA/Data/ ;i=10221",
                    12345,
                    System.TypeCode.Int32);
            }
            catch (UAException uaException)
            {
                Console.WriteLine($"*** Failure: {uaException.GetBaseException().Message}");
                return;
            }

            Console.WriteLine("Finished.");
        }
    }
}
# This example shows how to write a value into a single node, specifying a type code explicitly.
#
# Reasons for specifying the type explicitly might be:
# - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
# - The data type that the reports is incorrect.
# - Writing with an explicitly specified type is more efficient.
#
# TypeCode is easy to use, but it does not cover all possible types. It is also possible to specify the .NET Type, using
# a different overload of the WriteValue method.
#
# Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

#requires -Version 5.1
using namespace OpcLabs.EasyOpc.UA
using namespace OpcLabs.EasyOpc.UA.OperationModel

# The path below assumes that the current directory is [ProductDir]/Examples-NET/PowerShell/Windows .
Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcUA.dll"
Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcUAComponents.dll"

[UAEndpointDescriptor]$endpointDescriptor =
    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
# or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
# or "https://opcua.demo-this.com:51212/UA/SampleServer/"

# Instantiate the client object.
$client = New-Object EasyUAClient

Write-Host "Modifying value of a node..."
try {
    [IEasyUAClientExtension]::WriteValue($client,
        $endpointDescriptor, 
        "nsu=http://test.org/UA/Data/ ;i=10221", 
        12345,
        [System.TypeCode]::Int32)
}
catch [UAException] {
    Write-Host "*** Failure: $($PSItem.Exception.GetBaseException().Message)"
    return
}

Write-Host "Finished."
# This example shows how to write a value into a single node, specifying a type code explicitly.
#
# Reasons for specifying the type explicitly might be:
# - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
# - The data type that the reports is incorrect.
# - Writing with an explicitly specified type is more efficient.
#
# TypeCode is easy to use, but it does not cover all possible types. It is also possible to specify the .NET Type, using
# a different overload of the WriteValue method.
#
# Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
# OPC client and subscriber examples in Python on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-Python .
# The QuickOPC package is needed. Install it using "pip install opclabs_quickopc".
import opclabs_quickopc

# Import .NET namespaces.
from System import *
from OpcLabs.EasyOpc.UA import *
from OpcLabs.EasyOpc.UA.OperationModel import *


endpointDescriptor = UAEndpointDescriptor('opc.tcp://opcua.demo-this.com:51210/UA/SampleServer')
# or 'http://opcua.demo-this.com:51211/UA/SampleServer' (currently not supported)
# or 'https://opcua.demo-this.com:51212/UA/SampleServer/'

# Instantiate the client object.
client = EasyUAClient()

print('Modifying value of a node...')
try:
    IEasyUAClientExtension.WriteValue(client,
        endpointDescriptor,
        UANodeDescriptor('nsu=http://test.org/UA/Data/ ;i=10221'),
        12345,
        TypeCode.Int32)
except UAException as uaException:
    print('*** Failure: ' + uaException.GetBaseException().Message)
    exit()

print('Finished.')
' This example shows how to write a value into a single node, specifying a type code explicitly.
'
' Reasons for specifying the type explicitly might be:
' - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
' - The data type that the reports is incorrect.
' - Writing with an explicitly specified type is more efficient.
'
' TypeCode is easy to use, but it does not cover all possible types. It is also possible to specify the .NET Type, using
' a different overload of the WriteValue method.
'
' Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

Imports OpcLabs.EasyOpc.UA
Imports OpcLabs.EasyOpc.UA.OperationModel

Namespace _EasyUAClient
    Partial Friend Class WriteValue
        Public Shared Sub TypeCode()

            ' Define which server we will work with.
            Dim endpointDescriptor As UAEndpointDescriptor =
                    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
            ' or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
            ' or "https://opcua.demo-this.com:51212/UA/SampleServer/"

            ' Instantiate the client object
            Dim client = New EasyUAClient()

            ' Modify value of a node
            Try
                client.WriteValue( _
                    endpointDescriptor, _
                    "nsu=http://test.org/UA/Data/ ;i=10221", _
                    12345, _
                    System.TypeCode.Int32)
            Catch uaException As UAException
                Console.WriteLine("*** Failure: {0}", uaException.GetBaseException.Message)
                Exit Sub
            End Try
        End Sub
    End Class
End Namespace

COM

// This example shows how to write a value into a single node, specifying a type code explicitly.
//
// Reasons for specifying the type explicitly might be:
// - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
// - The data type that the reports is incorrect.
// - Writing with an explicitly specified type is more efficient.
//
// TypeCode is easy to use, but it does not cover all possible types. It is also possible
// to specify the .NET Type, using a different overload of the WriteValue method.
//
// Find all latest examples here : https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .


class procedure WriteValue.TypeCode;
var
  Arguments: OleVariant;
  Client: OpcLabs_EasyOpcUA_TLB._EasyUAClient;
  EndpointDescriptorUrlString: string;
  WriteResult: _UAWriteResult;
  WriteValueArguments1: _UAWriteValueArguments;
  Results: OleVariant;
begin
  EndpointDescriptorUrlString :=
    //'http://opcua.demo-this.com:51211/UA/SampleServer';
    //'https://opcua.demo-this.com:51212/UA/SampleServer/';
    'opc.tcp://opcua.demo-this.com:51210/UA/SampleServer';

  // Prepare the arguments
  WriteValueArguments1 := CoUAWriteValueArguments.Create;
  WriteValueArguments1.EndpointDescriptor.UrlString := EndpointDescriptorUrlString;
  WriteValueArguments1.NodeDescriptor.NodeId.ExpandedText := 'nsu=http://test.org/UA/Data/ ;i=10221';
  WriteValueArguments1.Value := 12345;
  WriteValueArguments1.ValueTypeCode := TypeCode_Int32;    // here is the type explicitly specified

  Arguments := VarArrayCreate([0, 0], varVariant);
  Arguments[0] := WriteValueArguments1;

  // Instantiate the client object
  Client := CoEasyUAClient.Create;

  // Modify value of node
  TVarData(Results).VType := varArray or varVariant;
  TVarData(Results).VArray := PVarArray(Client.WriteMultipleValues(Arguments));

  WriteResult := IUnknown(Results[0]) as _UAWriteResult;
  if not WriteResult.Succeeded then
    WriteLn('*** Failure: ', WriteResult.Exception.GetBaseException.Message);

  VarClear(Results);
  VarClear(Arguments);
end;
// This example shows how to write a value into a single node, specifying a type code explicitly.
//
// Reasons for specifying the type explicitly might be:
// - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
// - The data type that the reports is incorrect.
// - Writing with an explicitly specified type is more efficient.
//
// TypeCode is easy to use, but it does not cover all possible types. It is also possible
// to specify the .NET Type, using a different overload of the WriteValue method.
//
// Find all latest examples here : https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

const TypeCode_Int32 = 9;

$EndpointDescriptor = 
    //"http://opcua.demo-this.com:51211/UA/SampleServer";
    //"https://opcua.demo-this.com:51212/UA/SampleServer/";
    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer";

// Prepare the arguments
$WriteValueArguments1 = new COM("OpcLabs.EasyOpc.UA.OperationModel.UAWriteValueArguments");
$WriteValueArguments1->EndpointDescriptor->UrlString = $EndpointDescriptor;
$WriteValueArguments1->NodeDescriptor->NodeId->ExpandedText = "nsu=http://test.org/UA/Data/ ;i=10221";
$WriteValueArguments1->Value = 12345;
$WriteValueArguments1->ValueTypeCode = TypeCode_Int32;    // here is the type explicitly specified

$arguments[0] = $WriteValueArguments1;

// Instantiate the client object
$Client = new COM("OpcLabs.EasyOpc.UA.EasyUAClient");

// Modify value of node
$results = $Client->WriteMultipleValues($arguments);

$WriteResult = $results[0];
if (!$WriteResult->Succeeded)
    printf("*** Failure: %s\n", $WriteResult->Exception->GetBaseException()->Message);
Rem This example shows how to write a value into a single node, specifying a type code explicitly.
Rem 
Rem Reasons for specifying the type explicitly might be:
Rem - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
Rem - The data type that the reports is incorrect.
Rem - Writing with an explicitly specified type is more efficient.
Rem 
Rem TypeCode is easy to use, but it does not cover all possible types. It is also possible to specify the .NET Type, using
Rem a different overload of the WriteValue method.
Rem
Rem Find all latest examples here : https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

Option Explicit

Const TypeCode_Int32 = 9

Dim endpointDescriptor: endpointDescriptor = _
    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
    '"http://opcua.demo-this.com:51211/UA/SampleServer"  
    '"https://opcua.demo-this.com:51212/UA/SampleServer/"

' Instantiate the client object
Dim Client: Set Client = CreateObject("OpcLabs.EasyOpc.UA.EasyUAClient")

' Prepare the arguments
Dim WriteValueArguments1: Set WriteValueArguments1 = CreateObject("OpcLabs.EasyOpc.UA.OperationModel.UAWriteValueArguments")
WriteValueArguments1.EndpointDescriptor.UrlString = endpointDescriptor
WriteValueArguments1.NodeDescriptor.NodeId.ExpandedText = "nsu=http://test.org/UA/Data/ ;i=10221"
WriteValueArguments1.Value = 12345
WriteValueArguments1.ValueTypeCode = TypeCode_Int32

Dim arguments(0)
Set arguments(0) = WriteValueArguments1

' Modify value of a node
Dim results: results = Client.WriteMultipleValues(arguments)
Dim WriteResult: Set WriteResult = results(0)
If Not WriteResult.Succeeded Then
    WScript.Echo "*** Failure: " & WriteResult.Exception.GetBaseException().Message
End If
REM This example shows how to write a value into a single node, specifying a type code explicitly.
REM
REM Reasons for specifying the type explicitly might be:
REM - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
REM - The data type that the reports is incorrect.
REM - Writing with an explicitly specified type is more efficient.
REM
REM TypeCode is easy to use, but it does not cover all possible types. It is also possible to specify the .NET Type, using
REM a different overload of the WriteValue method.
REM
REM Find all latest examples here : https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

Public Sub WriteValue_TypeCode_Command_Click()
    OutputText = ""
    
    Const TypeCode_Int32 = 9

    Dim endpointDescriptor As String
    'endpointDescriptor = "http://opcua.demo-this.com:51211/UA/SampleServer"
    'endpointDescriptor = "https://opcua.demo-this.com:51212/UA/SampleServer/"
    endpointDescriptor = "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"

    ' Instantiate the client object
    Dim Client As New EasyUAClient

    ' Prepare the arguments
    Dim WriteValueArguments1 As New UAWriteValueArguments
    WriteValueArguments1.endpointDescriptor.UrlString = endpointDescriptor
    WriteValueArguments1.nodeDescriptor.NodeId.expandedText = "nsu=http://test.org/UA/Data/ ;i=10221"
    WriteValueArguments1.SetValue 12345
    WriteValueArguments1.ValueTypeCode = TypeCode_Int32

    Dim arguments(0) As Variant
    Set arguments(0) = WriteValueArguments1

    ' Modify value of node
    Dim results As Variant
    results = Client.WriteMultipleValues(arguments)

    ' Display results
    Dim Result As UAWriteResult: Set Result = results(0)
    If Not Result.Succeeded Then
        OutputText = OutputText & "*** Failure: " & Result.Exception.GetBaseException().Message & vbCrLf
    End If
End Sub

Example 3:

The example below writes multiple values, specifying the types to be written in the ValueType property, using a .NET Type.

Note that this approach is, at least theoretically, also available in COM languages and tools, but due to difficulties with obtaining the .NET Type, you are much more likely to specify the type using the ValueTypeCode or ValueTypeFullName property, for which the examples are given further down.

// This example shows how to write values into 3 nodes at once, specifying a type explicitly. It tests for success of each 
// write and displays the exception message in case of failure.
//
// Reasons for specifying the type explicitly might be:
// - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
// - The data type that the reports is incorrect.
// - Writing with an explicitly specified type is more efficient.
//
// Alternative ways of specifying the type are using the ValueTypeCode or ValueTypeFullName properties.
//
// Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

using System;
using OpcLabs.BaseLib.OperationModel;
using OpcLabs.EasyOpc.UA;
using OpcLabs.EasyOpc.UA.OperationModel;

namespace UADocExamples._EasyUAClient
{
    partial class WriteMultipleValues
    {
        public static void ValueType()
        {
            UAEndpointDescriptor endpointDescriptor =
                "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer";
            // or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
            // or "https://opcua.demo-this.com:51212/UA/SampleServer/"

            // Instantiate the client object
            var client = new EasyUAClient();

            // Modify value of a node
            OperationResult[] operationResultArray = client.WriteMultipleValues(new[]
                {
                    new UAWriteValueArguments(endpointDescriptor, 
                        "nsu=http://test.org/UA/Data/ ;i=10221", 23456) 
                        {ValueType = typeof(Int32)},    // here is the type explicitly specified
                    new UAWriteValueArguments(endpointDescriptor,
                        "nsu=http://test.org/UA/Data/ ;i=10226", "This string cannot be converted to Double")
                        {ValueType = typeof(Double)},    // here is the type explicitly specified
                    new UAWriteValueArguments(endpointDescriptor,
                        "nsu=http://test.org/UA/Data/ ;s=UnknownNode", "ABC")
                        {ValueType = typeof(string)}    // here is the type explicitly specified
                });

            for (int i = 0; i < operationResultArray.Length; i++)
                if (operationResultArray[i].Succeeded)
                    Console.WriteLine("Result {0}: success", i);
                else
                    Console.WriteLine("Result {0}: {1}", i, operationResultArray[i].Exception.GetBaseException().Message);
        }
    }
}
' This example shows how to write values into 3 nodes at once, specifying a type explicitly. It tests for success of each 
' write and displays the exception message in case of failure.
'
' Reasons for specifying the type explicitly might be:
' - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
' - The data type that the reports is incorrect.
' - Writing with an explicitly specified type is more efficient.
'
' Alternative ways of specifying the type are using the ValueTypeCode or ValueTypeFullName properties.
'
' Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

Imports System
Imports OpcLabs.BaseLib.OperationModel
Imports OpcLabs.EasyOpc.UA
Imports OpcLabs.EasyOpc.UA.OperationModel

Namespace _EasyUAClient
    Partial Friend Class WriteMultipleValues
        Public Shared Sub ValueType()

            ' Define which server we will work with.
            Dim endpointDescriptor As UAEndpointDescriptor =
                    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
            ' or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
            ' or "https://opcua.demo-this.com:51212/UA/SampleServer/"

            ' Instantiate the client object
            Dim client = New EasyUAClient()

            ' Modify value of a node
            Dim operationResultArray() As OperationResult = client.WriteMultipleValues(New UAWriteValueArguments() _
                { _
                    New UAWriteValueArguments(endpointDescriptor, _
                        "nsu=http://test.org/UA/Data/ ;i=10221", 23456) _
                        With {.ValueType = GetType(Int32)}, _
                    New UAWriteValueArguments(endpointDescriptor, _
                        "nsu=http://test.org/UA/Data/ ;i=10226", "This string cannot be converted to Double") _
                        With {.ValueType = GetType(Double)}, _
                    New UAWriteValueArguments(endpointDescriptor, _
                        "nsu=http://test.org/UA/Data/ ;s=UnknownNode", "ABC") _
                        With {.ValueType = GetType(String)} _
                } _
             )

            For i As Integer = 0 To operationResultArray.Length - 1
                If operationResultArray(i).Succeeded Then
                    Console.WriteLine("Result {0}: success", i)
                Else
                    Console.WriteLine("Result {0}: {1}", i, operationResultArray(i).Exception.GetBaseException().Message)
                End If
            Next i
        End Sub
    End Class
End Namespace

Example 4:

The example below writes multiple values, specifying the types to be written in the ValueTypeCode property, using a TypeCode.

This approach is suitable for a basic set of types covered by the TypeCode enumeration, and is also accessible to COM languages and tools. If you need to specify a type that is not covered by the TypeCode enumeration, use the ValueType or ValueTypeFullName property instead.

.NET

// This example shows how to write values into 3 nodes at once, specifying a type code explicitly. It tests for success of 
// each write and displays the exception message in case of failure.
//
// Reasons for specifying the type explicitly might be:
// - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
// - The data type that the reports is incorrect.
// - Writing with an explicitly specified type is more efficient.
//
// Alternative ways of specifying the type are using the ValueType or ValueTypeFullName properties.
//
// Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

using System;
using OpcLabs.BaseLib.OperationModel;
using OpcLabs.EasyOpc.UA;
using OpcLabs.EasyOpc.UA.OperationModel;

namespace UADocExamples._EasyUAClient
{
    partial class WriteMultipleValues
    {
        public static void ValueTypeCode()
        {
            UAEndpointDescriptor endpointDescriptor =
                "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer";
            // or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
            // or "https://opcua.demo-this.com:51212/UA/SampleServer/"

            // Instantiate the client object.
            var client = new EasyUAClient();

            Console.WriteLine("Modifying values of nodes...");
            OperationResult[] operationResultArray = client.WriteMultipleValues(new[]
                {
                    new UAWriteValueArguments(endpointDescriptor, 
                        "nsu=http://test.org/UA/Data/ ;i=10221", 23456) 
                        {ValueTypeCode = TypeCode.Int32},    // here is the type explicitly specified
                    new UAWriteValueArguments(endpointDescriptor,
                        "nsu=http://test.org/UA/Data/ ;i=10226", "This string cannot be converted to Double")
                        {ValueTypeCode = TypeCode.Double},    // here is the type explicitly specified
                    new UAWriteValueArguments(endpointDescriptor,
                        "nsu=http://test.org/UA/Data/ ;s=UnknownNode", "ABC")
                        {ValueTypeCode = TypeCode.String}    // here is the type explicitly specified
                });

            for (int i = 0; i < operationResultArray.Length; i++)
                if (operationResultArray[i].Succeeded)
                    Console.WriteLine($"Result {i}: success");
                else
                    Console.WriteLine($"Result {i}: {operationResultArray[i].Exception.GetBaseException().Message}");


            // Example output:
            //
            //Modifying values of nodes...
            //Result 0: success
            //Result 1: Input string was not in a correct format.
            //+ Attempting to change an object of type "System.String" to type "System.Double".
            //+ The specified original value (string) was "This string cannot be converted to Double".
            //+ The node descriptor used was: NodeId="nsu=http://test.org/UA/Data/ ;i=10226".
            //+ The client method called (or event/callback invoked) was 'WriteMultiple[3]'.
            //Result 2: OPC UA service result - {BadNodeIdUnknown}. The node id refers to a node that does not exist in the server address space.
            //+ The node descriptor used was: NodeId="nsu=http://test.org/UA/Data/ ;s=UnknownNode".
            //+ The client method called (or event/callback invoked) was 'WriteMultiple[3]'.
        }
    }
}
# This example shows how to write values into 3 nodes at once, specifying a type code explicitly. It tests for success of 
# each write and displays the exception message in case of failure.
#
# Reasons for specifying the type explicitly might be:
# - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
# - The data type that the reports is incorrect.
# - Writing with an explicitly specified type is more efficient.
#
# Alternative ways of specifying the type are using the ValueType or ValueTypeFullName properties.
#
# Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

#requires -Version 5.1
using namespace OpcLabs.EasyOpc.UA
using namespace OpcLabs.EasyOpc.UA.OperationModel

# The path below assumes that the current directory is [ProductDir]/Examples-NET/PowerShell/Windows .
Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcUA.dll"
Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcUAComponents.dll"

[UAEndpointDescriptor]$endpointDescriptor =
    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
# or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
# or "https://opcua.demo-this.com:51212/UA/SampleServer/"

# Instantiate the client object.
$client = New-Object EasyUAClient

Write-Host "Modifying values of nodes..."
$operationResultArray = $client.WriteMultipleValues([UAWriteValueArguments[]]@(
        (New-Object UAWriteValueArguments($endpointDescriptor, "nsu=http://test.org/UA/Data/ ;i=10221", 23456) `
            -Property @{ValueTypeCode = [TypeCode]::Int32}), # here is the type explicitly specified
        (New-Object UAWriteValueArguments($endpointDescriptor, "nsu=http://test.org/UA/Data/ ;i=10226", 
            "This string cannot be converted to Double") `
            -Property @{ValueTypeCode = [TypeCode]::Double}), # here is the type explicitly specified
        (New-Object UAWriteValueArguments($endpointDescriptor, "nsu=http://test.org/UA/Data/ ;s=UnknownNode", "ABC") `
            -Property @{ValueTypeCode = [TypeCode]::String}) # here is the type explicitly specified
    ))

for ($i = 0; $i -lt $operationResultArray.Length; $i++) {
    if ($operationResultArray[$i].Succeeded) {
        Write-Host "Result $($i): success"
    }
    else {
        Write-Host "Result $($i): $($operationResultArray[$i].Exception.GetBaseException().Message)"
    }
}


# Example output:
#
#Modifying values of nodes...
#Result 0: success
#Result 1: Input string was not in a correct format.
#+ Attempting to change an object of type "System.String" to type "System.Double".
#+ The specified original value (string) was "This string cannot be converted to Double".
#+ The node descriptor used was: NodeId="nsu=http://test.org/UA/Data/ ;i=10226".
#+ The client method called (or event/callback invoked) was 'WriteMultiple[3]'.
#Result 2: The status of the OPC-UA attribute data is not Good. The actual status is 'BadNodeIdUnknown'.
#+ During writing or method calls, readings may occur when value type is not specified.
#+ The node descriptor used was: NodeId="nsu=http://test.org/UA/Data/ ;s=UnknownNode".
#+ The client method called (or event/callback invoked) was 'WriteMultiple[3]'.

# This example shows how to write values into 3 nodes at once, specifying a type code explicitly. It tests for success
# of each write and displays the exception message in case of failure.
#
# Reasons for specifying the type explicitly might be:
# - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
# - The data type that the reports is incorrect.
# - Writing with an explicitly specified type is more efficient.
#
# Alternative ways of specifying the type are using the ValueType or ValueTypeFullName properties.
#
# Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
# OPC client and subscriber examples in Python on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-Python .
# The QuickOPC package is needed. Install it using "pip install opclabs_quickopc".
import opclabs_quickopc

# Import .NET namespaces.
from System import *
from OpcLabs.EasyOpc.UA import *
from OpcLabs.EasyOpc.UA.OperationModel import *


endpointDescriptor = UAEndpointDescriptor('opc.tcp://opcua.demo-this.com:51210/UA/SampleServer')
# or 'http://opcua.demo-this.com:51211/UA/SampleServer' (currently not supported)
# or 'https://opcua.demo-this.com:51212/UA/SampleServer/'

# Instantiate the client object
client = EasyUAClient()

print('Modifying values of nodes...')
writeValueArguments1 = UAWriteValueArguments(endpointDescriptor,
                                             UANodeDescriptor('nsu=http://test.org/UA/Data/ ;i=10221'), 23456)
writeValueArguments1.ValueTypeCode = TypeCode.Int32 # here is the type explicitly specified
writeValueArguments2 = UAWriteValueArguments(endpointDescriptor,
                                             UANodeDescriptor('nsu=http://test.org/UA/Data/ ;i=10226'),
                                             'This string cannot be converted to Double')
writeValueArguments2.ValueTypeCode = TypeCode.Double # here is the type explicitly specified
writeValueArguments3 = UAWriteValueArguments(endpointDescriptor,
                                             UANodeDescriptor('nsu=http://test.org/UA/Data/ ;s=UnknownNode'),
                                             'ABC')
writeValueArguments3.ValueTypeCode = TypeCode.String # here is the type explicitly specified

writeResultArray = IEasyUAClientExtension.WriteMultipleValues(client,
    [writeValueArguments1, writeValueArguments2, writeValueArguments3])

for i, writeResult in enumerate(writeResultArray):
    if writeResult.Succeeded:
        print('writeResultArray[', i, ']: success', sep='')
    else:
        print('writeResultArray[', i, '] *** Failure: ', writeResult.Exception.GetBaseException().Message, sep='')

print()
print('Finished.')
' This example shows how to write values into 3 nodes at once, specifying a type code explicitly. It tests for success of 
' each write and displays the exception message in case of failure.
'
' Reasons for specifying the type explicitly might be:
' - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
' - The data type that the reports is incorrect.
' - Writing with an explicitly specified type is more efficient.
'
' Alternative ways of specifying the type are using the ValueType or ValueTypeFullName properties.
'
' Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

Imports System
Imports OpcLabs.BaseLib.OperationModel
Imports OpcLabs.EasyOpc.UA
Imports OpcLabs.EasyOpc.UA.OperationModel

Namespace _EasyUAClient
    Partial Friend Class WriteMultipleValues
        Public Shared Sub ValueTypeCode()

            ' Define which server we will work with.
            Dim endpointDescriptor As UAEndpointDescriptor =
                    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
            ' or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
            ' or "https://opcua.demo-this.com:51212/UA/SampleServer/"

            ' Instantiate the client object
            Dim client = New EasyUAClient()

            ' Modify value of a node
            Dim operationResultArray() As OperationResult = client.WriteMultipleValues(New UAWriteValueArguments() _
                { _
                    New UAWriteValueArguments(endpointDescriptor, _
                        "nsu=http://test.org/UA/Data/ ;i=10221", 23456) _
                        With {.ValueTypeCode = TypeCode.Int32}, _
                    New UAWriteValueArguments(endpointDescriptor, _
                        "nsu=http://test.org/UA/Data/ ;i=10226", "This string cannot be converted to Double") _
                        With {.ValueTypeCode = TypeCode.Double}, _
                    New UAWriteValueArguments(endpointDescriptor, _
                        "nsu=http://test.org/UA/Data/ ;s=UnknownNode", "ABC") _
                        With {.ValueTypeCode = TypeCode.String} _
                } _
             )

            For i As Integer = 0 To operationResultArray.Length - 1
                If operationResultArray(i).Succeeded Then
                    Console.WriteLine("Result {0}: success", i)
                Else
                    Console.WriteLine("Result {0}: {1}", i, operationResultArray(i).Exception.GetBaseException().Message)
                End If
            Next i
        End Sub
    End Class
End Namespace

COM

// This example shows how to write values into 3 nodes at once, specifying a type code explicitly. It tests for success of
// each write and displays the exception message in case of failure.
//
// Reasons for specifying the type explicitly might be:
// - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
// - The data type that the reports is incorrect.
// - Writing with an explicitly specified type is more efficient.
//
// Alternative ways of specifying the type are using the ValueType or ValueTypeFullName properties.
//
// Find all latest examples here : https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

class procedure WriteMultipleValues.ValueTypeCode;
var
  Arguments: OleVariant;
  Client: OpcLabs_EasyOpcUA_TLB._EasyUAClient;
  I: Cardinal;
  WriteResult: _UAWriteResult;
  WriteValueArguments1, WriteValueArguments2, WriteValueArguments3: _UAWriteValueArguments;
  Results: OleVariant;
begin
  WriteValueArguments1 := CoUAWriteValueArguments.Create;
  WriteValueArguments1.EndpointDescriptor.UrlString := 
    //'http://opcua.demo-this.com:51211/UA/SampleServer';
    //'https://opcua.demo-this.com:51212/UA/SampleServer/';
    'opc.tcp://opcua.demo-this.com:51210/UA/SampleServer';
  WriteValueArguments1.NodeDescriptor.NodeId.ExpandedText := 'nsu=http://test.org/UA/Data/ ;i=10221';
  WriteValueArguments1.Value := 23456;
  WriteValueArguments1.ValueTypeCode := TypeCode_Int32;    // here is the type explicitly specified

  WriteValueArguments2 := CoUAWriteValueArguments.Create;
  WriteValueArguments2.EndpointDescriptor.UrlString := 
    //'http://opcua.demo-this.com:51211/UA/SampleServer';
    //'https://opcua.demo-this.com:51212/UA/SampleServer/';
    'opc.tcp://opcua.demo-this.com:51210/UA/SampleServer';
  WriteValueArguments2.NodeDescriptor.NodeId.ExpandedText := 'nsu=http://test.org/UA/Data/ ;i=10226';
  WriteValueArguments2.Value := 'This string cannot be converted to Double';
  WriteValueArguments2.ValueTypeCode := TypeCode_Double;    // here is the type explicitly specified

  WriteValueArguments3 := CoUAWriteValueArguments.Create;
  WriteValueArguments3.EndpointDescriptor.UrlString := 
    //'http://opcua.demo-this.com:51211/UA/SampleServer';
    //'https://opcua.demo-this.com:51212/UA/SampleServer/';
    'opc.tcp://opcua.demo-this.com:51210/UA/SampleServer';
  WriteValueArguments3.NodeDescriptor.NodeId.ExpandedText := 'nsu=http://test.org/UA/Data/ ;s=UnknownNode';
  WriteValueArguments3.Value := 'ABC';
  WriteValueArguments3.ValueTypeCode := TypeCode_String;    // here is the type explicitly specified

  Arguments := VarArrayCreate([0, 2], varVariant);
  Arguments[0] := WriteValueArguments1;
  Arguments[1] := WriteValueArguments2;
  Arguments[2] := WriteValueArguments3;

  // Instantiate the client object
  Client := CoEasyUAClient.Create;

  // Modify values of nodes
  TVarData(Results).VType := varArray or varVariant;
  TVarData(Results).VArray := PVarArray(Client.WriteMultipleValues(Arguments));

  // Display results
  for I := VarArrayLowBound(Results, 1) to VarArrayHighBound(Results, 1) do
  begin
    WriteResult := IInterface(Results[I]) as _UAWriteResult;
    if WriteResult.Succeeded then
      WriteLn('Result ', I, ' success')
    else
      WriteLn('Result ', I, ': ', WriteResult.Exception.GetBaseException.Message);
  end;

  VarClear(Results);
  VarClear(Arguments);
end;
// This example shows how to write values into 3 nodes at once, specifying a type code explicitly. It tests for success of
// each write and displays the exception message in case of failure.
//
// Reasons for specifying the type explicitly might be:
// - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
// - The data type that the reports is incorrect.
// - Writing with an explicitly specified type is more efficient.
//
// Alternative ways of specifying the type are using the ValueType or ValueTypeFullName properties.
//
// Find all latest examples here : https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

const TypeCode_Int32 = 9;
const TypeCode_Double = 14;
const TypeCode_String = 18;

$WriteValueArguments1 = new COM("OpcLabs.EasyOpc.UA.OperationModel.UAWriteValueArguments");
$WriteValueArguments1->EndpointDescriptor->UrlString = 
    //"http://opcua.demo-this.com:51211/UA/SampleServer";
    //"https://opcua.demo-this.com:51212/UA/SampleServer/";
    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer";
$WriteValueArguments1->NodeDescriptor->NodeId->ExpandedText = "nsu=http://test.org/UA/Data/ ;i=10221";
$WriteValueArguments1->Value = 23456;
$WriteValueArguments1->ValueTypeCode = TypeCode_Int32;    // here is the type explicitly specified

$WriteValueArguments2 = new COM("OpcLabs.EasyOpc.UA.OperationModel.UAWriteValueArguments");
$WriteValueArguments2->EndpointDescriptor->UrlString = 
    //"http://opcua.demo-this.com:51211/UA/SampleServer";
    //"https://opcua.demo-this.com:51212/UA/SampleServer/";
    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer";
$WriteValueArguments2->NodeDescriptor->NodeId->ExpandedText = "nsu=http://test.org/UA/Data/ ;i=10226";
$WriteValueArguments2->Value = "This string cannot be converted to Double";
$WriteValueArguments2->ValueTypeCode = TypeCode_Double;    // here is the type explicitly specified

$WriteValueArguments3 = new COM("OpcLabs.EasyOpc.UA.OperationModel.UAWriteValueArguments");
$WriteValueArguments3->EndpointDescriptor->UrlString = 
    //"http://opcua.demo-this.com:51211/UA/SampleServer";
    //"https://opcua.demo-this.com:51212/UA/SampleServer/";
    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer";
$WriteValueArguments3->NodeDescriptor->NodeId->ExpandedText = "nsu=http://test.org/UA/Data/ ;s=UnknownNode";
$WriteValueArguments3->Value = "ABC";
$WriteValueArguments3->ValueTypeCode = TypeCode_String;    // here is the type explicitly specified

$arguments[0] = $WriteValueArguments1;
$arguments[1] = $WriteValueArguments2;
$arguments[2] = $WriteValueArguments3;

// Instantiate the client object
$Client = new COM("OpcLabs.EasyOpc.UA.EasyUAClient");

// Modify values of nodes
$results = $Client->WriteMultipleValues($arguments);

// Display results
for ($i = 0; $i < count($results); $i++)
{
    $WriteResult = $results[$i];
    if ($WriteResult->Succeeded)
        printf("Result %d success\n", $i);
    else
        printf("Result d: s \n", $i, $WriteResult->Exception->GetBaseException()->Message);
}
REM This example shows how to write values into 3 nodes at once, specifying a type code explicitly. It tests for success of
REM each write and displays the exception message in case of failure.
REM
REM Reasons for specifying the type explicitly might be:
REM - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
REM - The data type that the reports is incorrect.
REM - Writing with an explicitly specified type is more efficient.
REM
REM Alternative ways of specifying the type are using the ValueType or ValueTypeFullName properties.
REM
REM Find all latest examples here : https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

Public Sub WriteMultipleValues_ValueTypeCode_Command_Click()
    OutputText = ""

    Const TypeCode_Int32 = 9
    Const TypeCode_Double = 14
    Const TypeCode_String = 18

    ' Instantiate the client object
    Dim Client As New EasyUAClient

    Dim WriteValueArguments1 As New UAWriteValueArguments
    WriteValueArguments1.endpointDescriptor.UrlString = "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
    WriteValueArguments1.nodeDescriptor.NodeId.expandedText = "nsu=http://test.org/UA/Data/ ;i=10221"
    WriteValueArguments1.SetValue 23456
    WriteValueArguments1.ValueTypeCode = TypeCode_Int32    ' here is the type explicitly specified

    Dim WriteValueArguments2 As New UAWriteValueArguments
    WriteValueArguments2.endpointDescriptor.UrlString = "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
    WriteValueArguments2.nodeDescriptor.NodeId.expandedText = "nsu=http://test.org/UA/Data/ ;i=10226"
    WriteValueArguments2.SetValue "This string cannot be converted to Double"
    WriteValueArguments2.ValueTypeCode = TypeCode_Double    ' here is the type explicitly specified

    Dim WriteValueArguments3 As New UAWriteValueArguments
    WriteValueArguments3.endpointDescriptor.UrlString = "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
    WriteValueArguments3.nodeDescriptor.NodeId.expandedText = "nsu=http://test.org/UA/Data/ ;s=UnknownNode"
    WriteValueArguments3.SetValue "ABC"
    WriteValueArguments3.ValueTypeCode = TypeCode_String    ' here is the type explicitly specified

    Dim arguments(2) As Variant
    Set arguments(0) = WriteValueArguments1
    Set arguments(1) = WriteValueArguments2
    Set arguments(2) = WriteValueArguments3

    ' Modify values of nodes
    Dim results As Variant
    results = Client.WriteMultipleValues(arguments)

    ' Display results
    Dim i: For i = LBound(results) To UBound(results)
        Dim Result As UAWriteResult: Set Result = results(i)
        If Result.Succeeded Then
            OutputText = OutputText & "Result " & i & " success" & vbCrLf
        Else
            OutputText = OutputText & "Result " & i & ": " & Result.Exception.GetBaseException().Message & vbCrLf
        End If
    Next
End Sub

Example 5:

The example below writes multiple values, specifying the types to be written in the ValueTypeFullName property, using a string form of the .NET  Type.

This approach is especially suitable in COM languages and tools, if you need to specify a type that is not covered by the TypeCode enumeration.

.NET

// This example shows how to write values into 3 nodes at once, specifying a type's full name explicitly. It tests for 
// success of each write and displays the exception message in case of failure.
//
// Reasons for specifying the type explicitly might be:
// - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
// - The data type that the reports is incorrect.
// - Writing with an explicitly specified type is more efficient.
//
// Alternative ways of specifying the type are using the ValueType or ValueTypeCode properties.
//
// Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

using System;
using OpcLabs.BaseLib.OperationModel;
using OpcLabs.EasyOpc.UA;
using OpcLabs.EasyOpc.UA.OperationModel;

namespace UADocExamples._EasyUAClient
{
    partial class WriteMultipleValues
    {
        public static void ValueTypeFullName()
        {
            UAEndpointDescriptor endpointDescriptor =
                "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer";
            // or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
            // or "https://opcua.demo-this.com:51212/UA/SampleServer/"

            // Instantiate the client object.
            var client = new EasyUAClient();

            Console.WriteLine("Modifying values of nodes...");
            OperationResult[] operationResultArray = client.WriteMultipleValues(new[]
                {
                    new UAWriteValueArguments(endpointDescriptor, 
                        "nsu=http://test.org/UA/Data/ ;i=10221", 23456) 
                        {ValueTypeFullName = "System.Int32"},    // here is the type explicitly specified
                    new UAWriteValueArguments(endpointDescriptor,
                        "nsu=http://test.org/UA/Data/ ;i=10226", "This string cannot be converted to Double")
                        {ValueTypeFullName = "System.Double"},    // here is the type explicitly specified
                    new UAWriteValueArguments(endpointDescriptor,
                        "nsu=http://test.org/UA/Data/ ;s=UnknownNode", "ABC")
                        {ValueTypeFullName = "System.String"}    // here is the type explicitly specified
                });

            for (int i = 0; i < operationResultArray.Length; i++)
                if (operationResultArray[i].Succeeded)
                    Console.WriteLine($"Result {i}: success");
                else
                    Console.WriteLine($"Result {i}: {operationResultArray[i].Exception.GetBaseException().Message}");
        }
    }
}
# This example shows how to write values into 3 nodes at once, specifying a type's full name explicitly. It tests for 
# success of each write and displays the exception message in case of failure.
#
# Reasons for specifying the type explicitly might be:
# - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
# - The data type that the reports is incorrect.
# - Writing with an explicitly specified type is more efficient.
#
# Alternative ways of specifying the type are using the ValueType or ValueTypeCode properties.
#
# Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

#requires -Version 5.1
using namespace OpcLabs.EasyOpc.UA
using namespace OpcLabs.EasyOpc.UA.OperationModel

# The path below assumes that the current directory is [ProductDir]/Examples-NET/PowerShell/Windows .
Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcUA.dll"
Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcUAComponents.dll"

[UAEndpointDescriptor]$endpointDescriptor =
    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
# or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
# or "https://opcua.demo-this.com:51212/UA/SampleServer/"

# Instantiate the client object.
$client = New-Object EasyUAClient

Write-Host "Modifying values of nodes..."
$operationResultArray = $client.WriteMultipleValues([UAWriteValueArguments[]]@(
        (New-Object UAWriteValueArguments($endpointDescriptor, "nsu=http://test.org/UA/Data/ ;i=10221", 23456) `
            -Property @{ValueTypeFullName = "System.Int32"}), # here is the type explicitly specified
        (New-Object UAWriteValueArguments($endpointDescriptor, "nsu=http://test.org/UA/Data/ ;i=10226", 
            "This string cannot be converted to Double") `
            -Property @{ValueTypeFullName = "System.Double"}), # here is the type explicitly specified
        (New-Object UAWriteValueArguments($endpointDescriptor, "nsu=http://test.org/UA/Data/ ;s=UnknownNode", "ABC") `
            -Property @{ValueTypeFullName = "System.String"}) # here is the type explicitly specified
    ))

for ($i = 0; $i -lt $operationResultArray.Length; $i++) {
    if ($operationResultArray[$i].Succeeded) {
        Write-Host "Result $($i): success"
    }
    else {
        Write-Host "Result $($i): $($operationResultArray[$i].Exception.GetBaseException().Message)"
    }
}


# Example output:
#
#Modifying values of nodes...
#Result 0: success
#Result 1: Input string was not in a correct format.
#+ Attempting to change an object of type "System.String" to type "System.Double".
#+ The specified original value (string) was "This string cannot be converted to Double".
#+ The node descriptor used was: NodeId="nsu=http://test.org/UA/Data/ ;i=10226".
#+ The client method called (or event/callback invoked) was 'WriteMultiple[3]'.
#Result 2: The status of the OPC-UA attribute data is not Good. The actual status is 'BadNodeIdUnknown'.
#+ During writing or method calls, readings may occur when value type is not specified.
#+ The node descriptor used was: NodeId="nsu=http://test.org/UA/Data/ ;s=UnknownNode".
#+ The client method called (or event/callback invoked) was 'WriteMultiple[3]'.

# This example shows how to write values into 3 nodes at once, specifying a type's full name explicitly. It tests for
# success of each write and displays the exception message in case of failure.
#
# Reasons for specifying the type explicitly might be:
# - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
# - The data type that the reports is incorrect.
# - Writing with an explicitly specified type is more efficient.
#
# Alternative ways of specifying the type are using the ValueType or ValueTypeCode properties.
#
# Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
# OPC client and subscriber examples in Python on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-Python .
# The QuickOPC package is needed. Install it using "pip install opclabs_quickopc".
import opclabs_quickopc

# Import .NET namespaces.
from OpcLabs.EasyOpc.UA import *
from OpcLabs.EasyOpc.UA.OperationModel import *


endpointDescriptor = UAEndpointDescriptor('opc.tcp://opcua.demo-this.com:51210/UA/SampleServer')
# or 'http://opcua.demo-this.com:51211/UA/SampleServer' (currently not supported)
# or 'https://opcua.demo-this.com:51212/UA/SampleServer/'

# Instantiate the client object
client = EasyUAClient()

print('Modifying values of nodes...')
writeValueArguments1 = UAWriteValueArguments(endpointDescriptor,
                                             UANodeDescriptor('nsu=http://test.org/UA/Data/ ;i=10221'), 23456)
writeValueArguments1.ValueTypeFullName = 'System.Int32' # here is the type explicitly specified
writeValueArguments2 = UAWriteValueArguments(endpointDescriptor,
                                             UANodeDescriptor('nsu=http://test.org/UA/Data/ ;i=10226'),
                                             'This string cannot be converted to Double')
writeValueArguments2.ValueTypeFullName = 'System.Double' # here is the type explicitly specified
writeValueArguments3 = UAWriteValueArguments(endpointDescriptor,
                                             UANodeDescriptor('nsu=http://test.org/UA/Data/ ;s=UnknownNode'),
                                             'ABC')
writeValueArguments3.ValueTypeFullName = 'System.String' # here is the type explicitly specified

writeResultArray = IEasyUAClientExtension.WriteMultipleValues(client,
    [writeValueArguments1, writeValueArguments2, writeValueArguments3])

for i, writeResult in enumerate(writeResultArray):
    if writeResult.Succeeded:
        print('writeResultArray[', i, ']: success', sep='')
    else:
        print('writeResultArray[', i, '] *** Failure: ', writeResult.Exception.GetBaseException().Message, sep='')

print()
print('Finished.')
' This example shows how to write values into 3 nodes at once, specifying a type's full name explicitly. It tests for 
' success of each write and displays the exception message in case of failure.
'
' Reasons for specifying the type explicitly might be:
' - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
' - The data type that the reports is incorrect.
' - Writing with an explicitly specified type is more efficient.
'
' Alternative ways of specifying the type are using the ValueType or ValueTypeCode properties.
'
' Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

Imports System
Imports OpcLabs.BaseLib.OperationModel
Imports OpcLabs.EasyOpc.UA
Imports OpcLabs.EasyOpc.UA.OperationModel

Namespace _EasyUAClient
    Partial Friend Class WriteMultipleValues
        Public Shared Sub ValueTypeFullName()

            ' Define which server we will work with.
            Dim endpointDescriptor As UAEndpointDescriptor =
                    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
            ' or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
            ' or "https://opcua.demo-this.com:51212/UA/SampleServer/"

            ' Instantiate the client object
            Dim client = New EasyUAClient()

            ' Modify value of a node
            Dim operationResultArray() As OperationResult = client.WriteMultipleValues(New UAWriteValueArguments() _
                { _
                    New UAWriteValueArguments(endpointDescriptor, _
                        "nsu=http://test.org/UA/Data/ ;i=10221", 23456) _
                        With {.ValueTypeFullName = "System.Int32"}, _
                    New UAWriteValueArguments(endpointDescriptor, _
                        "nsu=http://test.org/UA/Data/ ;i=10226", "This string cannot be converted to Double") _
                        With {.ValueTypeFullName = "System.Double"}, _
                    New UAWriteValueArguments(endpointDescriptor, _
                        "nsu=http://test.org/UA/Data/ ;s=UnknownNode", "ABC") _
                        With {.ValueTypeFullName = "System.String"} _
                } _
             )

            For i As Integer = 0 To operationResultArray.Length - 1
                If operationResultArray(i).Succeeded Then
                    Console.WriteLine("Result {0}: success", i)
                Else
                    Console.WriteLine("Result {0}: {1}", i, operationResultArray(i).Exception.GetBaseException().Message)
                End If
            Next i
        End Sub
    End Class
End Namespace

COM

REM This example shows how to write values into 3 nodes at once, specifying a type's full name explicitly. It tests for
REM success of each write and displays the exception message in case of failure.
REM
REM Reasons for specifying the type explicitly might be:
REM - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
REM - The data type that the reports is incorrect.
REM - Writing with an explicitly specified type is more efficient.
REM
REM Alternative ways of specifying the type are using the ValueType or ValueTypeCode properties.
REM
REM Find all latest examples here : https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

Public Sub WriteMultipleValues_ValueTypeFullName_Command_Click()
    OutputText = ""

    ' Instantiate the client object
    Dim Client As New EasyUAClient

    Dim WriteValueArguments1 As New UAWriteValueArguments
    WriteValueArguments1.endpointDescriptor.UrlString = "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
    WriteValueArguments1.nodeDescriptor.NodeId.expandedText = "nsu=http://test.org/UA/Data/ ;i=10221"
    WriteValueArguments1.SetValue 23456
    WriteValueArguments1.ValueTypeFullName = "System.Int32"    ' here is the type explicitly specified

    Dim WriteValueArguments2 As New UAWriteValueArguments
    WriteValueArguments2.endpointDescriptor.UrlString = "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
    WriteValueArguments2.nodeDescriptor.NodeId.expandedText = "nsu=http://test.org/UA/Data/ ;i=10226"
    WriteValueArguments2.SetValue "This string cannot be converted to Double"
    WriteValueArguments2.ValueTypeFullName = "System.Double"    ' here is the type explicitly specified

    Dim WriteValueArguments3 As New UAWriteValueArguments
    WriteValueArguments3.endpointDescriptor.UrlString = "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
    WriteValueArguments3.nodeDescriptor.NodeId.expandedText = "nsu=http://test.org/UA/Data/ ;s=UnknownNode"
    WriteValueArguments3.SetValue "ABC"
    WriteValueArguments3.ValueTypeFullName = "System.String"    ' here is the type explicitly specified

    Dim arguments(2) As Variant
    Set arguments(0) = WriteValueArguments1
    Set arguments(1) = WriteValueArguments2
    Set arguments(2) = WriteValueArguments3

    ' Modify values of nodes
    Dim results As Variant
    results = Client.WriteMultipleValues(arguments)

    ' Display results
    Dim i: For i = LBound(results) To UBound(results)
        Dim Result As UAWriteResult: Set Result = results(i)
        If Result.Succeeded Then
            OutputText = OutputText & "Result " & i & " success" & vbCrLf
        Else
            OutputText = OutputText & "Result " & i & ": " & Result.Exception.GetBaseException().Message & vbCrLf
        End If
    Next
End Sub
// This example shows how to write values into 3 nodes at once, specifying a type's full name explicitly. It tests for
// success of each write and displays the exception message in case of failure.
//
// Reasons for specifying the type explicitly might be:
// - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written.
// - The data type that the reports is incorrect.
// - Writing with an explicitly specified type is more efficient.
//
// Alternative ways of specifying the type are using the ValueType or ValueTypeCode properties.
//
// Find all latest examples here : https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

class procedure WriteMultipleValues.ValueTypeFullName;
var
  Arguments: OleVariant;
  Client: OpcLabs_EasyOpcUA_TLB._EasyUAClient;
  I: Cardinal;
  WriteResult: _UAWriteResult;
  WriteValueArguments1, WriteValueArguments2, WriteValueArguments3: _UAWriteValueArguments;
  Results: OleVariant;
begin
  WriteValueArguments1 := CoUAWriteValueArguments.Create;
  WriteValueArguments1.EndpointDescriptor.UrlString := 
    //'http://opcua.demo-this.com:51211/UA/SampleServer';
    //'https://opcua.demo-this.com:51212/UA/SampleServer/';
    'opc.tcp://opcua.demo-this.com:51210/UA/SampleServer';
  WriteValueArguments1.NodeDescriptor.NodeId.ExpandedText := 'nsu=http://test.org/UA/Data/ ;i=10221';
  WriteValueArguments1.Value := 23456;
  WriteValueArguments1.ValueTypeFullName := 'System.Int32';    // here is the type explicitly specified

  WriteValueArguments2 := CoUAWriteValueArguments.Create;
  WriteValueArguments2.EndpointDescriptor.UrlString := 
    //'http://opcua.demo-this.com:51211/UA/SampleServer';
    //'https://opcua.demo-this.com:51212/UA/SampleServer/';
    'opc.tcp://opcua.demo-this.com:51210/UA/SampleServer';
  WriteValueArguments2.NodeDescriptor.NodeId.ExpandedText := 'nsu=http://test.org/UA/Data/ ;i=10226';
  WriteValueArguments2.Value := 'This string cannot be converted to Double';
  WriteValueArguments2.ValueTypeFullName := 'System.Double';    // here is the type explicitly specified

  WriteValueArguments3 := CoUAWriteValueArguments.Create;
  WriteValueArguments3.EndpointDescriptor.UrlString := 
    //'http://opcua.demo-this.com:51211/UA/SampleServer';
    //'https://opcua.demo-this.com:51212/UA/SampleServer/';
    'opc.tcp://opcua.demo-this.com:51210/UA/SampleServer';
  WriteValueArguments3.NodeDescriptor.NodeId.ExpandedText := 'nsu=http://test.org/UA/Data/ ;s=UnknownNode';
  WriteValueArguments3.Value := 'ABC';
  WriteValueArguments3.ValueTypeFullName := 'System.String';    // here is the type explicitly specified

  Arguments := VarArrayCreate([0, 2], varVariant);
  Arguments[0] := WriteValueArguments1;
  Arguments[1] := WriteValueArguments2;
  Arguments[2] := WriteValueArguments3;

  // Instantiate the client object
  Client := CoEasyUAClient.Create;

  // Modify values of nodes
  TVarData(Results).VType := varArray or varVariant;
  TVarData(Results).VArray := PVarArray(Client.WriteMultipleValues(Arguments));

  // Display results
  for I := VarArrayLowBound(Results, 1) to VarArrayHighBound(Results, 1) do
  begin
    WriteResult := IInterface(Results[I]) as _UAWriteResult;
    if WriteResult.Succeeded then
      WriteLn('Result ', I, ' success')
    else
      WriteLn('Result ', I, ': ', WriteResult.Exception.GetBaseException.Message);
  end;

  VarClear(Results);
  VarClear(Arguments);
end;

 

 

See Also